AOL File Library: 2,801 to 2,900/aol-file-protocol-4400-2801-to-2900.zip/AOLDLs/C++ Files Library/FFT and Complex Numbers Library/FFTLibrary.sit/FFT library ƒ/Complex ƒ/ComplexNumbers.h

Text File | 1995-01-15 | 5KB | 180 lines

//
//    File: ComplexNumbers.h
//    Copyright ⌐1994-1995 James Wilson
//    All rights reserved.
//
//    This file is a more Macintosh-compatible version of the complex class
//    used in the iostreams library. Among the changes, the size of the real and
//    imaginary components are now doubles instead of long doubles. This is for PowerPC
//    compatibility. I have replaced all references to int with long. The
//    << and >> I/O operators are not in this class; the Macintosh interface has other
//    and better ways to handle standard I/O with the user. I have also done my best
//    to eliminate the use of friends and other questionable C++ constructs from this
//    implementation. To match with with Macintosh class naming style conventions,
//    the name of this class is Complex. Much of the implementation code is from
//    the original complex source files, some modified to be more Macintosh and
//    ANSI-C++ compatible.

#if defined(__SC__)
#pragma once
#endif

#ifndef __COMPLEXNUMBERS__
#define __COMPLEXNUMBERS__

#if macintosh
    #if defined(powerc)
        #include <math.h>
    #else
        #if defined(__SC__)
            #if __option(mc68881)
                #include <math.h>
            #else
                #ifndef __SANE__
                    #include <SANE.h>
                #endif
            #endif
        #else
            #include <math.h>
        #endif
    #endif
#else
    #include <math.h>
#endif

#if macintosh
    #ifndef __TYPES__
        enum {false, true};
    #endif
#else
    enum {false, true};
#endif

typedef double FP_TYPE;

class Complex {
public:

    // Constructors
    Complex();
    Complex(const FP_TYPE re, const FP_TYPE im);
    Complex(const Complex& copy);                // Complex's copy constructor

    // Indirect access functions
    FP_TYPE& Real();
    FP_TYPE& Imag();

    // These functions return only values not references.
    FP_TYPE Re() const;
    FP_TYPE Im() const;

    // Overloaded operators

    // operator+
    Complex operator+(const Complex&) const;
    Complex operator+(const FP_TYPE) const;
    friend Complex operator+(const FP_TYPE, const Complex&);

    // operator-
    Complex operator-(const Complex&) const;
    Complex operator-(const FP_TYPE) const;
    friend Complex operator-(const FP_TYPE, const Complex&);

    // operator*
    Complex operator*(const Complex&) const;
    Complex operator*(const FP_TYPE) const;
    friend Complex operator*(const FP_TYPE, const Complex&);

    // operator/
    Complex operator/(const Complex&) const;
    Complex operator/(const FP_TYPE) const;
    friend Complex operator/(const FP_TYPE, const Complex&);

    // operator&&
    long operator&&(const Complex&) const;
    long operator&&(const FP_TYPE) const;
    friend long operator&&(const FP_TYPE, const Complex&);

    // operator||
    long operator||(const Complex&) const;
    long operator||(const FP_TYPE) const;
    friend long operator||(const FP_TYPE, const Complex&);

    // operator==
    long operator==(const Complex&) const;
    long operator==(const FP_TYPE) const;
    friend long operator==(const FP_TYPE, const Complex&);

    // operator !=
    long operator!=(const Complex&) const;
    long operator!=(const FP_TYPE) const;
    friend long operator!=(const FP_TYPE, const Complex&);

    // Unary operators
    long operator!() const;

    Complex operator-() const;

    // Overloaded operators returning references

    // operator=
    Complex& operator=(const Complex&);
    Complex& operator=(const FP_TYPE);

    // operator+=
    Complex& operator+=(const Complex&);
    Complex& operator+=(const FP_TYPE);

    // operator-=
    Complex& operator-=(const Complex&);
    Complex& operator-=(const FP_TYPE);

    // operator*=
    Complex& operator*=(const Complex&);
    Complex& operator*=(const FP_TYPE);

    // operator/=
    Complex& operator/=(const Complex&);
    Complex& operator/=(const FP_TYPE);

private:
    FP_TYPE                real;
    FP_TYPE                imag;
};

// Prototypes of complex number functions

FP_TYPE Abs(const Complex&);
FP_TYPE Mod(const Complex&);
FP_TYPE Arg(const Complex&);
Complex Conj(const Complex&);

// Inline member functions

inline Complex::Complex(void) : real(0.0), imag(0.0) { }
inline Complex::Complex(const FP_TYPE re, const FP_TYPE im) : real(re), imag(im) { }
inline Complex::Complex(const Complex& z) : real(z.real), imag(z.imag) { }

inline FP_TYPE& Complex::Real(void) { return real; }
inline FP_TYPE& Complex::Imag(void) { return imag; }

inline FP_TYPE Complex::Re(void) const { return real; }
inline FP_TYPE Complex::Im(void) const { return imag; }

inline long Complex::operator!(void) const
{
    return ((Re()==0) && (Im()==0)) ? true : false;
}

inline Complex Complex::operator-(void) const
{
    return Complex(-Re(), -Im());
}

inline FP_TYPE Mod(const Complex& z)
{
    return Abs(z);
}

#endif